<template>
	<!-- AI智能对话组件主容器 -->
	<view class="byt-aidialogue" :class="{ 'is-default-bg': !config.main.background }" :style="aidialogueStyle">
		<!-- 顶部导航栏 -->
		<Navbar :title="agentNameAgent" bgColor="transparent" :backShow="backShow" :borShow="false">
			<slot></slot>
		</Navbar>

		<!-- 对话主体区域 -->
		<view class="byt-aidialogue-bg">
			<!-- 背景角色装饰图片 -->
			<image v-if="config.main.role" class="byt-aidialogue-bg__role"
				:src="`https://img.yummall.cn/baiyetong/byt-uni-ui/role_${config.main.role}.svg`"></image>

			<!-- 顶部欢迎语和推荐消息区域 -->
			<view class="byt-aidialogue-header" :style="{ background: config.startup.backgroundColor }"
				v-if="config.startup.welcomeShow">
				<!-- AI助手欢迎组件 -->
				<Welcome :colorIcon="colorIconAgent" class="byt-aidialogue-bg--float" :show="timerShow"
					:description="config.startup.tip" :icon="config.startup.avatar"
					:rightIcon="config.startup.rightIcon" :rotateIcon="config.startup.rotateIcon"></Welcome>

				<!-- 推荐问题提示组件（带淡入淡出动画） -->
				<transition name="fade">
					<Prompts ref="prompts" :colorIcon="colorIconAgent" @itemClick="problemClick"
						v-if="mockMode ? (promptItems && promptItems.length > 0) : (showRecommendedMessages && config.guess && (promptItems && promptItems.length > 0))"
						:items="promptItems" :supportChange="promptSupportsChange" @change="onPromptsChange"
						class="recommended-messages"></Prompts>
				</transition>
			</view>

			<!-- 中间可滚动的对话消息列表区域 -->
			<view class="byt-aidialogue-content byt-aidialogue-bg--float">
				<BubbleList :colorIcon="colorIconAgent" :typeWhiteList="config.typeWhiteList" :roles="config.roles"
					:items="bubbleItems" :scrollTop="scrollTop" @scrolltoupper="onPull" :status="recordLoading"
					@response="setResponse" :loading="answerStatus">
					<!-- 自定义消息内容插槽 -->
					<template v-slot:content="{ }">
					</template>

					<!-- 消息列表底部插槽：显示重连按钮 -->
					<template #footer>
						<view v-if="resizeBtnShow"
							style="display: flex; flex-direction: row; justify-content: center; align-items: center; margin-top: 24rpx">
							<basic-icon size="32rpx" style="height: 32rpx"
								:name="colorIconAgent.refreshIcon ? colorIconAgent.refreshIcon : 'https://img.yummall.cn/baiyetong/byt-uni-ui/refresh.svg'"></basic-icon>
							<text @click="wxResize"
								:style="{ color: colorIconAgent.textMainColor ? colorIconAgent.textMainColor : '#1890ff', 'margin-left': '8rpx' }">
								重新链接
							</text>
						</view>
					</template>
				</BubbleList>
			</view>

			<!-- 底部固定的消息输入和工具栏区域 -->
			<view class="byt-aidialogue-input-area">
				<!-- Vue2版本：使用.sync语法糖进行双向绑定 -->
				<!-- #ifdef VUE2 -->
				<!-- eslint-disable vue/no-deprecated-v-bind-sync -->
				<Sender :colorIcon="colorIconAgent" :loading="answerStatus" :audioShow="config.audio"
					:quickShow="config.quickShow" :moreListShow="config.moreListShow" :microphone.sync="microphone"
					:message.sync="message" @focus="onFocus" @submit="sendMessage" :slotTopShow="toolListShow"
					:moreShow.sync="moreShow" :moreList="moreListAgent">
					<!-- 工具栏插槽：深度思考、联网搜索等功能 -->
					<template v-if="toolListShow" #top>
						<ToolList :colorIcon="colorIconAgent" :items="toolListAgent" :activeList.sync="activeList">
						</ToolList>
					</template>
				</Sender>
				<!-- eslint-enable vue/no-deprecated-v-bind-sync -->
				<!-- #endif -->

				<!-- Vue3版本：使用v-model进行双向绑定 -->
				<!-- #ifdef VUE3 -->
				<Sender :colorIcon="colorIconAgent" :loading="answerStatus" :audioShow="config.audio"
					:quickShow="config.quickShow" :moreListShow="config.moreListShow" v-model:microphone="microphone"
					v-model:message="message" @focus="onFocus" @submit="sendMessage" :slotTopShow="toolListShow"
					v-model:moreShow="moreShow" :moreList="moreListAgent">
					<!-- 工具栏插槽：深度思考、联网搜索等功能 -->
					<template v-if="toolListShow" #top>
						<ToolList :colorIcon="colorIconAgent" :items="toolListAgent" v-model:activeList="activeList">
						</ToolList>
					</template>
				</Sender>
				<!-- #endif -->
			</view>
		</view>
	</view>
</template>

<script>
// 工具函数导入
import {
	isJsonString,       // JSON字符串验证
	getCurrentDateTime, // 获取当前时间
	isEmpty,           // 空值判断
	showToast,         // 消息提示
	debounce,          // 防抖函数
	Group              // 数据分组函数
} from '../../../utils/index.js';

// API接口导入
import {
	clearChatMessage,     // 清除对话上下文
	getChatHistoryList,      // 获取历史消息列表
	chatOpenNewHistory,   // 创建新对话历史
	chatTechnologyDetail, // 获取智能体详情
	getDefaultAgent,      // 获取默认智能体
	checkApiConfig        // 检查API配置
} from '../../../common/agent-api.js';

// Mock模拟数据导入（开发/演示用）
import {
	getChatHistoryListMook  // 模拟历史消息列表获取函数
} from '../../../common/demoMook.js';

// 推荐问题API导入
import {
	chatGuessProblem  // 获取推荐问题
} from '../../../common/agent-api.js';

// 组件导入
import BasicIcon from '../../basic/basic-icon/basic-icon.vue';  // 基础图标组件
import Prompts from '../../core/Prompts/Prompts.vue';           // 推荐问题组件
import BubbleList from '../../core/BubbleList/BubbleList.vue';  // 对话气泡列表组件
import Welcome from '../../core/Welcome/Welcome.vue';           // 欢迎语组件
import Navbar from '../../core/Navbar/Navbar.vue';             // 顶部导航组件
import Sender from '../../core/Sender/Sender.vue';             // 消息输入组件
import ToolList from '../../core/ToolList/ToolList.vue';       // 工具栏组件

// 基础配置导入
import baseConfig from '../../../common/config.js';
const {
	wsUrl,      // WebSocket连接地址
	wsChatPath, // WebSocket路径
	getToken ,
	moke   // 获取用户token
} = baseConfig;

export default {
	name: 'BytDialogue', // 组件名称
	components: {
		BasicIcon,  // 基础图标组件
		Welcome,    // 欢迎语组件
		Prompts,    // 推荐问题组件
		BubbleList, // 消息气泡列表组件
		Navbar,     // 顶部导航组件
		Sender,     // 消息输入组件
		ToolList    // 工具栏组件
	},
	props: {
		// 组件配置对象 - 包含所有UI和功能配置
		config: {
			type: Object,
			default: () => ({
				// 颜色和图标
				colorIcon: {
					// 主题色
					mainColor: '#448ef7',
					// 辅助色
					assistColor: '#a8ecff',
					// 字体主色
					textMainColor: '#1890ff',
					// 渐变色
					linearColor: '#27c9ff,#a8ecff',

					// 用户消息字体颜色
					userTextColor: '#FFFFFF',
					// 用户消息背景色
					userBgColor: '#448ef7',

					// 做活动按钮图标
					actionIcon: 'https://img.yummall.cn/baiyetong/byt-uni-ui/action.svg',
					// 复制按钮图标
					copyIcon: 'https://img.yummall.cn/baiyetong/byt-uni-ui/copy.svg',
					// 重新提问图标
					refreshIcon: 'https://img.yummall.cn/baiyetong/byt-uni-ui/refresh.svg',

					// 猜你想问背景颜色
					guessBgColor: 'url(https://img.yummall.cn/baiyetong/byt-uni-ui/whiteMengDefauld.svg)',
					// 猜你想问换一换 字体颜色
					guessChangeColor: '#1890ff',
					// 猜你想问换一换图标
					guessChange: 'https://img.yummall.cn/baiyetong/byt-uni-ui/guess_change.svg',
					//猜你想问文字头部左边图标
					guessIcon: 'https://img.yummall.cn/baiyetong/byt-uni-ui/guess_icon.svg',

					// 发送框左边图标
					sendLeftIcon: 'https://img.yummall.cn/baiyetong/byt-uni-ui/sendLeft233.svg',
					// 发送框右边发送按钮
					sendRightIcon: 'https://img.yummall.cn/baiyetong/byt-uni-ui/sendBtn.svg',
					// 发送框快速提问关闭图标
					sendQuickCloseIcon: 'https://img.yummall.cn/baiyetong/byt-uni-ui/quickIconClose.svg',
					// 发送框快速提问内容左侧图标
					sendQuickContentLeftIcon: 'https://img.yummall.cn/baiyetong/byt-uni-ui/quickIcon1.svg'
				},
				// 头部启动栏欢迎语
				startup: {
					// 头部欢迎栏是否显示
					welcomeShow: true,
					// 欢迎语
					tip: '我是红商AI助手。您有任何关于红商集团的问题，我可以随时帮您解答。',
					//欢迎语人物头像
					avatar: 'https://img.yummall.cn/baiyetong/byt-uni-ui/role_icon_1.svg', // 1,2
					// 头像回答旋转动效图标
					rotateIcon: 'https://img.yummall.cn/baiyetong/byt-uni-ui/header_icon_outline.png',
					// 欢迎语右边背景图标
					rightIcon: 'https://img.yummall.cn/baiyetong/byt-uni-ui/header_banner_right.png',
					// 欢迎栏的渐变背景色
					backgroundColor: 'linear-gradient(90deg, #E7FCF6 0%, #F7FFEE 50%, #DFF8FF 100%);'

				},
				// 主体内容
				main: {
					// 背景色
					// (1.数字类型， 1-4
					background: 1,
					// (2.对象类型 { type: 'image' | 'linear' | 'coLor' }
					//背景图片
					// background: {
					// 	type: 'image',
					// 	url: "https://img.yummall.cn/baiyetong/byt-uni-ui/role_icon_1.svg", // 1-4
					// },
					//渐变色
					// background: {
					// 	type: 'linear',
					// 	url: "-webkit-linear-gradient(top, #ffffff, #f3f4f8 120rpx)", // 1-4
					// },
					//纯色
					// background: {
					// 	type: 'color',
					// 	url: "rgb(217 224 255)", // 1-4
					// },
					// 背景角色图片
					role: 1 // 1-4
				},
				// 发送框工具栏功能
				toolList: [{
					id: 1,
					icon: 'https://img.yummall.cn/baiyetong/byt-uni-ui/shendu.svg',
					activeiIcon: 'https://img.yummall.cn/baiyetong/byt-uni-ui/shendu_active2.svg',
					name: '深度思考'
				},
				{
					id: 2,
					icon: 'https://img.yummall.cn/baiyetong/byt-uni-ui/lianwang.svg',
					activeiIcon: 'https://img.yummall.cn/baiyetong/byt-uni-ui/lianwang_avtive2.svg',
					name: '联网搜索'
				}
				],
				// 更多工具
				moreList: [{
					id: 1,
					icon: 'https://img.yummall.cn/baiyetong/byt-uni-ui/paishe.svg',
					name: '拍摄'
				},
				{
					id: 1,
					icon: 'https://img.yummall.cn/baiyetong/byt-uni-ui/xiangce.svg',
					name: '相册'
				},
				{
					id: 2,
					icon: 'https://img.yummall.cn/baiyetong/byt-uni-ui/luyin.svg',
					name: '录音'
				},

				{
					id: 2,
					icon: 'https://img.yummall.cn/baiyetong/byt-uni-ui/wendang.svg',
					name: '文档'
				}
				],
				// 更多工具显示开关
				moreListShow: true,
				// 快速提问显示开关
				quickShow: true,

				// 猜你喜欢提示语组件显示开关
				guess: true,
				// 推荐问题列表（当没有智能体ID或API调用失败时使用）
				promptItems: [
					{
						btnName: '功能',
						text: '图表'
					},
					{
						btnName: '功能',
						text: '商品'
					},
					{
						btnName: '功能',
						text: '优惠券'
					},
					{
						btnName: '功能',
						text: '活动'
					}
				],
				// 输入框音频识别开关
				audio: true,
				// 基础消息配置
				message: {
					// 回答等待状态提示语
					answerWait: 'AI助手思考中',
					// 打开组件问候语
					greeting: '您好！有什么可以帮助您的？'
				},
				// 支持的消息类型，目前支持 text、chart，其他类型后续待开发
				typeWhiteList: ['text', 'activity', 'coupon', 'goods', 'chart', 'tables', 'action', 'image'],
				// 消息角色配置
				roles: {
					// AI助手消息配置
					ai: {
						// 有名称就显示，没有就不显示
						name: 'AI助手',
						// 头像
						avatar: 'https://img.yummall.cn/baiyetong/byt-uni-ui/role_icon_1.svg', // 1,2
						// 位置
						placement: 'start'
					},
					// 用户消息配置
					user: {
						name: '用户名称1',
						avatar: 'https://img.yummall.cn/baiyetong/byt-uni-ui/default_avatar.png',
						placement: 'end'
					}
				},
				// 业务用户信息
				userInfo: {
					//用户id必传，查询历史消息需要
					userId: '1670672134393978882'
				}
			})
		},

		/**
		 * AI智能体ID（必传）
		 * 使用说明：
		 * 1. 有智能体列表页面：根据token查询智能体列表，点击后传入ID
		 * 2. 无智能体列表页面：调用获取默认智能体接口，获取ID后传入
		 */
		agentId: {
			type: String,
			default: '',
			required: true
		},

		// 对话头部显示的智能体名称
		agentName: {
			type: String,
			default: 'AI助手'
		},

		// 组件整体宽度
		width: {
			type: String,
			default: '100%'
		},

		// 组件整体高度
		height: {
			type: String,
			default: '100vh'
		},

		// 是否显示头部返回按钮
		backShow: {
			type: Boolean,
			default: true
		},

		// 是否使用Mock模式（开发/演示用，无需真实API）
		mockModeProp: {
			type: Boolean,
			default: false
		}
	},
	data() {
		return {
			// ==================== 深度思考相关 ====================
			deepThink: false,            // 当前是否在深度思考模式
			deepThinkTime: 0,            // 深度思考已用时间(秒)
			deepThinkSetTimes: '0',      // 深度思考计时器ID

			// ==================== 图片生成相关 ====================
			answerImgSrcShow: false,    // 是否正在显示图片生成动画
			answerImgSrc: '',          // 图片地址缓存

			// ==================== UI状态相关 ====================
			moreShow: false,           // 更多工具面板是否显示
			statusBarHeight: 0,        // 手机状态栏高度

			// ==================== 工具栏相关 ====================
			activeList: [],            // 当前激活的工具功能ID数组

			// ==================== 智能体信息 ====================
			agentIdAgent: '',          // 当前使用的智能体ID
			agentNameAgent: '',        // 当前使用的智能体名称

			// ==================== WebSocket重连相关 ====================
			wxFailureRetryLimit: 3,       // WebSocket重连最大尝试次数
			wxFailureRetryNum: 0,         // 当前重连尝试次数
			resizeBtnShow: false,         // 是否显示重连按钮

			// ==================== 数据加载相关 ====================
			uuid: '',                     // 唯一标识符
			loading: false,               // 数据加载状态
			recordList: this.config.guess ? [{ type: 3 }] : [], // 消息记录列表

			// 分页查询参数
			queryParams: {
				pagination: {
					pageNum: 0,           // 当前页码
					pageSize: 10          // 每页数量
				},
				dialogueHistoryNo: ''     // 对话历史编号
			},
			recordLoading: 'loadmore',    // 记录加载状态: 'loadmore'|'loading'|'nomore'

			// ==================== 对话状态相关 ====================
			answerStatus: false,          // AI是否正在回答
			answerChart: false,           // 当前回答是否为图表数据
			message: null,                // 当前输入的消息内容
			microphone: false,            // 麦克风状态

			// ==================== UI布局相关 ====================
			scrollTop: 99999999,          // 滚动位置（滚动到底部）

			// ==================== WebSocket连接相关 ====================
			socketTask: null,             // WebSocket连接实例（兼容旧代码）
			wsManager: null,              // WebSocket管理工具类实例（企业级单例）
			aiMessageUnsubscribe: null,   // AI消息订阅取消函数
			deepThinkUnsubscribe: null,   // 深度思考消息订阅取消函数
			heartbeatTimeoutUnsubscribe: null, // 心跳超时事件取消函数
			stateChangeUnsubscribe: null, // 状态变化事件取消函数
			is_open_socket: false,        // WebSocket是否已连接

			// ==================== 定时器相关 ====================
			timer: null,                  // 回答动画定时器
			timerShow: false,             // 是否显示定时器动画
			jumpTimer: null,              // 心跳定时器

			// ==================== 会话管理相关 ====================
			historyId: '',                // 当前对话历史ID

			// ==================== 响应式适配相关 ====================
			wideScreenWidth: 700,         // 大屏判断阈值(px)
			isWideScreen: false,          // 是否为大屏设备

			// ==================== 业务数据相关 ====================
			dataList: [],                 // 数据列表
			aiForm: {},                   // 智能体详情表单
			taskOrnamentStr: null,        // 任务装饰字符串

			// ==================== 推荐消息相关 ====================
			showRecommendedMessages: true, // 是否显示推荐消息
			promptItems: [                 // 推荐问题数据 - 直接设置默认值
				{ group: '功能', text: '图表', id: 'default_1' },
				{ group: '功能', text: '商品', id: 'default_2' },
				{ group: '功能', text: '优惠券', id: 'default_3' },
				{ group: '功能', text: '活动', id: 'default_4' }
			],
			promptSupportsChange: false,   // 是否支持换一换功能
			promptApiLoading: false        // 推荐问题API加载状态
		};
	},
	created() {


	},
	computed: {
		// ==================== Mock模式判断 ====================

		/**
		 * 是否为Mock模式（基于环境变量和props）
		 * @returns {boolean} 是否开启Mock模式
		 */
		mockMode() {
			const viteMockMode = moke;
			const vueAppMockMode =moke;

			console.log('mockMode', moke);



			return this.mockModeProp ||
				viteMockMode === 'true' ||
				viteMockMode === true ||
				vueAppMockMode === 'true' ||
				vueAppMockMode === true;
		},

		// ==================== 工具栏相关计算属性 ====================

		/**
		 * 工具栏是否显示
		 * @returns {boolean} 有工具列表且不为空时显示
		 */
		toolListShow() {
			return this.config.toolList && this.config.toolList.length > 0;
		},

		/**
		 * 获取工具栏配置列表
		 * @returns {Array} 工具栏配置数组
		 */
		toolListAgent() {
			return this.config.toolList ? this.config.toolList : [];
		},

		/**
		 * 获取更多工具配置列表
		 * @returns {Array} 更多工具配置数组
		 */
		moreListAgent() {
			return this.config.moreList ? this.config.moreList : [];
		},

		/**
		 * 获取主题色和图标配置
		 * @returns {Object} 颜色和图标配置对象
		 */
		colorIconAgent() {
			return this.config.colorIcon ? this.config.colorIcon : {};
		},

		// ==================== 消息数据相关计算属性 ====================

		/**
		 * 格式化的消息气泡数据列表
		 * 将原始消息数据转换为气泡组件所需的格式
		 * @returns {Array} 格式化后的消息列表
		 */
		bubbleItems: function () {
			const list = this.recordList.map((item) => {
				return {
					// 业务数据，可以插槽使用
					...item,
					// key
					key: item.serialNo,
					// 创建时间
					createTime: item.createTime,
					// 角色信息
					role: item.type == 1 ? 'user' : item.type == 2 ? 'ai' : 'slot',
					// 内容
					content: item.content,
					// 深度思考状态
					deepThinkStatus: item.deepThinkStatus || false,
					// 深度思考内容
					deepThinkContent: item.deepThinkContent || '',
					// 深度思考时间
					deepThinkTime: item.deepThinkTime || 0,
					// 内容类型：'text', 'activity', 'coupon', 'goods', 'chart', 'tables', 'action', 'image'
					contentType: item.contentType || 'text',
					// 'chart', 'tables'类型的json数据字符串
					contentAppendData: item.contentAppendData || null
				};
			});

			return list;
		},

		// ==================== 样式相关计算属性 ====================

		/**
		 * 对话组件主容器样式
		 * 根据配置动态生成背景样式（支持预设图片、自定义图片、渐变色、纯色）
		 * @returns {string} CSS样式字符串
		 */
		aidialogueStyle: function () {
			let { background } = this.config.main;
			let backgroundKey = 'background-image';
			let backgroundValue = '';

			// 数字类型：使用预设背景图片（1-4）
			if (typeof background == 'number') {
				backgroundValue = `url('https://img.yummall.cn/baiyetong/byt-uni-ui/bg2${this.isWideScreen ? '' : '_min'}_${background}.png')`;
			}
			// 对象类型：根据type使用不同背景类型
			else if (background && typeof background == 'object') {
				if (background.type == 'image') {
					// 自定义背景图片
					backgroundValue = `url(${background.url})`;
				} else if (background.type == 'linear') {
					// 渐变背景
					backgroundValue = background.url;
				} else if (background.type == 'color') {
					// 纯色背景
					backgroundKey = 'background-color';
					backgroundValue = background.url;
				}
			}

			return `width: ${this.width} ; height: ${this.height};  ${backgroundKey}: ${backgroundValue}`;
		}
	},
	/**
	 * 组件挂载完成后的初始化流程
	 * 1. 确保API配置已正确初始化
	 * 2. 根据模式（Mock/正式）进行不同的初始化流程
	 * 3. 设置设备信息和事件监听
	 */
	async mounted() {
		// 第一步：检查并初始化API配置（小程序兼容）
		await this.ensureApiConfig();

		// 第二步：根据模式初始化对话功能
		if (this.mockMode) {
			// Mock模式：完全跳过连接建立和API调用，仅初始化基础信息
			this.agentIdAgent = this.agentId || 'mock-agent-id';
			this.agentNameAgent = this.agentName;

			// Mock模式：直接设置连接状态，无需建立真实连接
			this.is_open_socket = true;
			this.resizeBtnShow = false;

			// Mock模式：延迟显示欢迎语（模拟连接完成）
			setTimeout(() => {
				this.debounceShowGreeting();
			}, 300);
		} else {
			// 正式模式：需要获取智能体信息和建立真实连接
			if (!this.agentId) {
				// 未传入智能体ID，请求默认智能体
				await this.getAssistant();
			} else {
				// 已传入智能体ID，直接使用
				this.agentIdAgent = this.agentId;
				this.agentNameAgent = this.agentName;
			}
			// 创建对话历史并建立WebSocket连接
			await this.historyAdd();
		}

		// 第三步：获取推荐问题数据（不论哪种模式都要执行）
		if (this.config.guess) {
			// Mock模式：如果created中的初始化失败，再次尝试
			if (this.mockMode && (!this.promptItems || this.promptItems.length === 0)) {
				this.initMockPromptsData();
			} else {
				await this.getPromptsData();
			}
		}

		// 第四步：设置设备信息和事件监听
		let _this = this;

		// 获取设备信息并判断是否为大屏设备
		uni.getSystemInfo({
			success: function (info) {
				console.log('设备的宽度：' + info.windowWidth);
				let deviceWidth = info.windowWidth;
				// 根据设备宽度判断是否为大屏（影响背景图片选择）
				if (deviceWidth >= _this.wideScreenWidth) {
					_this.isWideScreen = true;
				} else {
					_this.isWideScreen = false;
				}
				console.log('当前isWideScreen', _this.isWideScreen);
			}
		});

		// 移动端：监听键盘高度变化，自动滚动到底部
		//  #ifndef H5
		uni.onKeyboardHeightChange((res) => {
			console.log('键盘高度变化:', res);
			_this.toBottom(); // 键盘弹起时滚动到底部
			if (res.height === 0) {
				_this.focus = false; // 键盘收起时取消焦点
			}
		});
		// #endif

		// H5端：监听窗口大小变化，重新判断是否为大屏
		// #ifdef H5
		window.addEventListener('resize', _this.onResizeWidth);
		// #endif

		// 获取系统状态栏高度（用于布局计算）
		const systemInfo = uni.getSystemInfoSync();
		this.statusBarHeight = systemInfo.statusBarHeight;
	},
	// #ifdef VUE2
	beforeDestroy() {
		this.onClear();
	},
	// #endif
	// #ifdef VUE3
	beforeUnmount() {
		this.onClear();
	},
	// #endif
	methods: {
		// 引入工具函数
		isEmpty,
		isJsonString,

		// ==================== 推荐问题相关方法 ====================

		/**
		 * 初始化Mock模式下的推荐问题数据
		 * 在created生命周期中调用，确保数据早期可用
		 */
		initMockPromptsData() {
			// 获取配置中的数据
			const configData = this.config.promptItems || [];

			// 如果配置中有数据，使用配置数据；否则使用内置默认数据
			const rawData = configData.length > 0 ? configData : [
				{ btnName: '功能', text: '图表' },
				{ btnName: '功能', text: '商品' },
				{ btnName: '服务', text: '优惠券' },
				{ btnName: '服务', text: '活动' },
				{ btnName: '帮助', text: '使用指南' },
				{ btnName: '帮助', text: '常见问题' }
			];

			// 转换数据格式
			this.promptItems = rawData.map((item, index) => ({
				group: item.btnName || item.group || '默认',
				text: item.text || item.name || item.title || '未知问题',
				id: item.id || `init_${index}`,
				...item
			}));

			// 确保每个项目都有group字段
			this.promptItems.forEach(item => {
				if (!item.group) {
					item.group = '默认';
				}
			});

			// 设置换一换功能支持
			const groups = [...new Set(this.promptItems.map(item => item.group))];
			this.promptSupportsChange = groups.length > 1;

			// 调试信息
			console.log('🔍 换一换功能调试:');
			console.log('  - promptItems:', this.promptItems);
			console.log('  - groups:', groups);
			console.log('  - promptSupportsChange:', this.promptSupportsChange);

			// 确保显示状态为true
			this.showRecommendedMessages = true;
		},

		/**
		 * 获取推荐问题列表
		 * 根据智能体ID调用API获取推荐问题，并格式化数据
		 */
		async getPromptsData() {
			if (!this.agentIdAgent || this.mockMode) {
				// Mock模式或无智能体ID时，使用配置的默认数据并转换格式
				const rawData = this.config.promptItems || [];

				// 如果配置数据为空，提供默认的后备数据
				if (rawData.length === 0) {
					const fallbackData = [
						{ btnName: '功能', text: '图表' },
						{ btnName: '功能', text: '商品' },
						{ btnName: '服务', text: '优惠券' },
						{ btnName: '服务', text: '活动' },
						{ btnName: '帮助', text: '使用指南' },
						{ btnName: '帮助', text: '常见问题' }
					];
					this.promptItems = fallbackData.map((item, index) => ({
						group: item.btnName || '默认',
						text: item.text || '未知问题',
						id: `fallback_${index}`,
						...item
					}));

					// 确保每个项目都有group字段
					this.promptItems.forEach(item => {
						if (!item.group) {
							item.group = '默认';
						}
					});
				} else {
					// 转换配置数据格式以匹配组件期望的格式
					this.promptItems = rawData.map((item, index) => ({
						group: item.btnName || item.group || '默认',
						text: item.text || item.name || item.title || '未知问题',
						id: item.id || `config_${index}`,
						...item  // 保留原始数据
					}));

					// 确保每个项目都有group字段
					this.promptItems.forEach(item => {
						if (!item.group) {
							item.group = '默认';
						}
					});
				}

				// 检查是否有多个分组（支持换一换功能）
				const groups = [...new Set(this.promptItems.map(item => item.group))];
				this.promptSupportsChange = groups.length > 1;

				// 调试信息
				console.log('🔍 Mock模式换一换功能调试:');
				console.log('  - promptItems:', this.promptItems);
				console.log('  - groups:', groups);
				console.log('  - promptSupportsChange:', this.promptSupportsChange);

				// 确保在Mock模式下推荐问题始终显示
				this.showRecommendedMessages = true;
				return;
			}

			this.promptApiLoading = true;

			try {
				const response = await chatGuessProblem({
					aiAgentId: this.agentIdAgent
				});

				const rawData = response.data || [];

				// 数据排序
				const sortedData = rawData.sort((a, b) => {
					const timeA = a.problemCategoryId || 0;
					const timeB = b.problemCategoryId || 0;
					return timeA - timeB;
				});

				// 按btnName分组
				const groupedData = Group(sortedData, 'btnName');

				// 转换为组件需要的格式
				this.promptItems = this.convertPromptsData(groupedData);
				this.promptSupportsChange = Object.keys(groupedData).length > 1;

			} catch (error) {
				console.error('获取推荐问题失败:', error);
				// 失败时使用配置的默认数据
				this.promptItems = this.config.promptItems || [];
				this.promptSupportsChange = false;
				showToast('获取推荐问题失败，使用默认数据');
			} finally {
				this.promptApiLoading = false;
			}
		},

		/**
		 * 转换推荐问题数据格式
		 * 将API返回的分组数据转换为组件需要的格式
		 * @param {Object} groupedData 分组后的数据
		 * @returns {Array} 转换后的数据数组
		 */
		convertPromptsData(groupedData) {
			const result = [];

			Object.keys(groupedData).forEach(groupKey => {
				const items = groupedData[groupKey] || [];
				items.forEach(item => {
					result.push({
						group: groupKey,  // 分组键名（用于换一换功能）
						text: item.text || item.name || item.title || '未知问题',
						id: item.id,
						...item  // 保留原始数据
					});
				});
			});

			return result;
		},

		/**
		 * 推荐问题换一换事件处理
		 * @param {Object} changeData 换一换事件数据
		 */
		onPromptsChange(changeData) {
			// 可以在这里添加换一换的统计或其他逻辑
			console.log('推荐问题换一换:', changeData);
		},



		// ==================== API配置相关方法 ====================

		/**
		 * 确保API配置已正确初始化（兼容小程序和H5环境）
		 * 小程序环境会动态加载专用配置文件，H5环境依赖全局配置
		 */
		async ensureApiConfig() {
			// Mock模式下直接跳过API配置检查
			if (this.mockMode) {
				console.log('Mock模式：跳过API配置检查');
				return;
			}

			// 如果API已配置，直接返回
			if (checkApiConfig()) {
				console.log('AI Agent API already configured');
				return;
			}

			// 尝试动态加载配置
			try {
				// #ifdef MP-WEIXIN
				// 小程序环境：使用专用配置文件
				const { initAiAgentMP } = await import('~/ai-agent-config-mp.js');
				const success = await initAiAgentMP();
				if (success) {
					console.log('AI Agent API configured for mini-program');
				} else {
					console.warn('AI Agent API configuration failed for mini-program');
				}
				// #endif

				// #ifndef MP-WEIXIN
				// 非小程序环境：使用全局配置
				console.warn('AI Agent API not configured. Please check ai-agent-config.js initialization.');
				// #endif
			} catch (error) {
				console.error('Failed to load AI Agent API configuration:', error);
				if (!this.mockMode) {
					console.warn('Falling back to mock mode due to API configuration failure');
					// 在API加载失败时，可以考虑强制使用mock模式
				}
			}
		},

		// ==================== 智能体信息获取方法 ====================
		/**
		 * 获取默认智能体信息
		 * 当组件未传入agentId时，自动获取平台默认智能体
		 */
		async getAssistant() {
			try {
				// agentType应用类型: 1-系统appAgent, 2-品牌官, 3-数字分身, 4-通用copilot
				const data = await getDefaultAgent({
					agentType: 1
				});
				console.log('获取默认智能体返回数据:', data?.data);

				const dataObj = data?.data || {};
				// 兼容不同字段名称的智能体ID
				const agentId = dataObj.agentId || dataObj.aiAgentId;
				const agentName = dataObj.agentName;

				// 设置当前使用的智能体信息
				this.agentIdAgent = agentId;
				this.agentNameAgent = agentName;

				console.log(`成功获取默认智能体: ${agentName}(${agentId})`);
			} catch (error) {
				console.error('获取默认智能体失败:', error);
				showToast('获取智能体信息失败，请稍后重试');
			}
		},

		// ==================== WebSocket连接相关方法 ====================

		/**
		 * 组件清理方法
		 * 在组件销毁前执行清理工作，防止内存泄漏
		 */
		onClear() {
			// H5端：移除窗口大小变化监听器
			// #ifdef H5
			window.removeEventListener('resize', this.onResizeWidth);
			// #endif

			// 取消WebSocket消息订阅
			if (this.aiMessageUnsubscribe) {
				this.aiMessageUnsubscribe();
				this.aiMessageUnsubscribe = null;
			}

			if (this.deepThinkUnsubscribe) {
				this.deepThinkUnsubscribe();
				this.deepThinkUnsubscribe = null;
			}

			if (this.heartbeatTimeoutUnsubscribe) {
				this.heartbeatTimeoutUnsubscribe();
				this.heartbeatTimeoutUnsubscribe = null;
			}

			if (this.stateChangeUnsubscribe) {
				this.stateChangeUnsubscribe();
				this.stateChangeUnsubscribe = null;
			}

			// 关闭WebSocket连接（必须在实例销毁之前关闭，否则会出现undefined错误）
			this.closeSocket();

			// 正式模式：清除服务端对话上下文
			if (!this.mockMode) {
				clearChatMessage({
					agentId: this.agentIdAgent,
					userId: this.config.userInfo.userId
				}).catch(error => {
					console.warn('清除对话上下文失败:', error);
				});
			}
		},
		onResizeWidth() {
			if (window.innerWidth >= this.wideScreenWidth) {
				this.isWideScreen = true;
			} else {
				this.isWideScreen = false;
			}
			console.log('当前isWideScreen', this.isWideScreen);
		},

		onPull() {
			console.info('用户向上滚动请求历史消息');
			if (this.recordLoading === 'nomore') {
				uni.stopPullDownRefresh();
				return;
			}
			this.queryParams.pagination.pageNum++;
			this.getChatHistoryData(true);

			// 只有在存在历史消息记录的情况下才隐藏推荐问题
			// 如果没有真实的对话消息（只有type: 3的占位消息），则保持推荐问题显示
			const hasRealMessages = this.recordList.some(item => item.type === 1 || item.type === 2);
			if (hasRealMessages) {
				this.showRecommendedMessages = false;
				console.log('🔧 存在历史消息，隐藏推荐问题');
			} else {
				console.log('🔧 无历史消息，保持推荐问题显示');
			}
		},
		problemClick(name) {
			this.message = name;
			this.sendMessage();
		},
		getChatHistoryData(stopPullDownRefresh = false) {
			this.recordLoading = 'loading';

			if (this.mockMode) {
				// Mock模式：使用模拟数据
				getChatHistoryListMook(this.queryParams).then((data) => {
					this.recordList = [...data, ...this.recordList];
					if (data.length < this.queryParams.pagination.pageSize) {
						this.recordLoading = 'nomore';
					} else {
						this.recordLoading = 'loadmore';
					}
					if (stopPullDownRefresh) {
						uni.stopPullDownRefresh();
					}
				});
			} else {
				// 正式模式：使用真实API
				getChatHistoryList(this.queryParams)
					.then((res) => {
						let data2 = res.data;
						data2.sort((a, b) => {
							// return a.serialNo - b.serialNo;
							return a.createTime?.localeCompare(b.createTime);
						});
						// 修复数据图表
						data2.forEach((item) => {
							try {
								if (item.type == 2) {
									let obj = JSON.parse(item.content);
									if (typeof obj == 'object' && obj instanceof Object) {
										item.content = obj.answerResult;
										if (obj.chartType) {
											item.contentType = 'chart_' + obj.chartType;
											item.contentAppendData = obj.chartData;
										}
									}
								}
							} catch {
								// 忽略解析错误
							}
						});
						// 去除空数据
						let data = data2.filter((item) => item.content);
						console.log('数据是', data2);
						this.recordList = [...data, ...this.recordList];
						this.loading = false;
						if (!data || data.length < this.queryParams.pagination.pageSize) {
							this.recordLoading = 'nomore';
						} else {
							this.recordLoading = 'loadmore';
						}
						if (stopPullDownRefresh) {
							uni.stopPullDownRefresh();
						}
					})
					.catch((err) => {
						showToast(err.msg);
					});
			}
		},

		/**
		 * 初始化WebSocket连接
		 * 使用企业级WebSocketManager单例管理连接，支持发布订阅、类型化消息等高级功能
		 *
		 * 核心特性：
		 * - 🔄 单例模式，确保全应用唯一实例
		 * - 📢 发布订阅模式，支持多组件消息订阅
		 * - 🎯 类型化消息，智能路由不同消息类型
		 * - 🔄 指数退避重连策略
		 * - 💓 智能心跳检测机制
		 * - 📝 消息队列与优先级处理
		 * - 🎭 Mock模式，完美支持开发测试
		 * - 🧠 深度思考，AI高级功能支持
		 */
		async connectSocketInit() {
			const _this = this;

			try {
				// Mock模式下的快速初始化
				if (_this.mockMode) {
					console.log('Mock模式：快速初始化连接状态');

					// 动态引入WebSocket管理工具类
					const WebSocketManager = (await import('@/uni_modules/byt-ai-agent-uni/common/WebSocketManager.js')).default;

					// 构建Mock模式配置
					const wsConfig = _this.buildWebSocketConfig();
					console.log('Mock WebSocket配置:', wsConfig);

					// 获取WebSocketManager单例实例
					_this.wsManager = WebSocketManager.getInstance(wsConfig);

					// 设置事件监听器和消息订阅
					_this.setupWebSocketListeners();

					// Mock模式：立即连接（不建立真实WebSocket）
					await _this.wsManager.connect();

					// 手动设置连接状态（确保Mock模式下状态正确）
					_this.is_open_socket = true;
					_this.resizeBtnShow = false;

					console.log('Mock模式连接初始化完成，状态已设置');
					return;
				}

				// 正式模式的连接初始化
				console.log('正式模式：开始建立真实WebSocket连接');

				// 动态引入WebSocket管理工具类（避免打包时的依赖问题）
				const WebSocketManager = (await import('@/uni_modules/byt-ai-agent-uni/common/WebSocketManager.js')).default;

				// 构建WebSocket连接配置
				const wsConfig = _this.buildWebSocketConfig();

				// 获取WebSocketManager单例实例
				_this.wsManager = WebSocketManager.getInstance(wsConfig);

				// 设置事件监听器和消息订阅
				_this.setupWebSocketListeners();

				// 开始建立连接
				console.log('开始建立真实WebSocket连接...', {
					agentId: _this.agentIdAgent,
					instanceId: _this.wsManager.connectionId,
					url: wsConfig.url
				});
				await _this.wsManager.connect();

			} catch (error) {
				console.error('WebSocket初始化失败:', error);
				_this.handleWebSocketInitError(error);
			}
		},

		/**
		 * 构建WebSocket连接配置
		 * 根据当前模式和环境生成完整的连接配置，使用新的企业级配置结构
		 * @returns {Object} WebSocket配置对象
		 */
		buildWebSocketConfig() {
			const _this = this;

			// 企业级WebSocket配置
			const config = {
				// ==================== 基础连接信息 ====================
				mockMode: _this.mockMode,
				historyId: _this.historyId || 'mock-history-id',
				agentId: _this.agentIdAgent,

				// ==================== 重连策略配置 ====================
				reconnect: {
					enabled: !_this.mockMode, // Mock模式下禁用重连
					maxAttempts: _this.wxFailureRetryLimit || 5,
					baseDelay: 2000,
					maxDelay: 30000,
					useExponentialBackoff: true
				},

				// ==================== 心跳检测配置 ====================
				heartbeat: {
					enabled: !_this.mockMode, // Mock模式下禁用心跳
					interval: 20000,
					message: { type: 'ping', agentId: _this.agentIdAgent },
					timeout: 8000,
					loseLimit: 3
				},

				// ==================== 消息队列配置 ====================
				queue: {
					enabled: true,
					maxSize: 100,
					persistOnReconnect: !_this.mockMode // Mock模式下禁用重连持久化
				},

				// ==================== 消息压缩配置 ====================
				compression: {
					enabled: false, // 暂时禁用，后续可以开启
					threshold: 1024,
					algorithm: 'simple'
				},

				// ==================== 日志配置 ====================
				logging: {
					enabled: true,
					level: _this.mockMode ? 'debug' : 'info',
					prefix: '[AI-WebSocket]'
				}
			};

			// 根据模式设置不同的连接参数
			if (_this.mockMode) {
				// Mock模式配置 - 完全不建立真实连接
				config.url = null;  // Mock模式设置为null，避免尝试连接
				config.token = null; // Mock模式不需要token
				console.log('配置Mock模式WebSocket连接（完全模拟）', {
					mockMode: true,
					agentId: _this.agentIdAgent,
					historyId: config.historyId
				});
			} else {
				// 正式模式配置
				config.url = `${wsUrl}${wsChatPath}/${_this.historyId}/${_this.agentIdAgent}`;
				config.token = getToken();
				console.log('配置正式模式WebSocket连接', {
					hasToken: !!config.token,
					agentId: _this.agentIdAgent,
					url: config.url
				});
			}

			return config;
		},

		/**
		 * 设置WebSocket事件监听器和消息订阅
		 * 使用新的发布订阅模式和类型化消息处理
		 */
		setupWebSocketListeners() {
			const _this = this;

			// ==================== 连接生命周期事件 ====================

			/**
			 * WebSocket连接成功事件
			 * 连接建立后的初始化工作
			 */
			_this.wsManager.onConnected((eventData) => {
				console.log('WebSocket连接成功建立', {
					connectionId: eventData.connectionId,
					timestamp: eventData.timestamp,
					mockMode: _this.mockMode
				});

				// 更新连接状态
				_this.is_open_socket = true;
				_this.resizeBtnShow = false;
				_this.wxFailureRetryNum = 0;

				// Mock模式特殊处理
				if (_this.mockMode) {
					console.log('Mock模式连接已建立，无真实WebSocket连接');
				}

				// 发送欢迎语（防抖延迟发送，避免连接刚建立就发送）
				_this.debounceShowGreeting();

				// 触发自定义连接成功事件（供外部监听）
				_this.$emit('websocket-connected', {
					connectionId: eventData.connectionId,
					agentId: _this.agentIdAgent,
					mockMode: _this.mockMode
				});
			});

			/**
			 * 订阅AI对话消息
			 * 使用类型化消息订阅处理AI对话流
			 */
			_this.aiMessageUnsubscribe = _this.wsManager.subscribe('*', (messageData, rawMessage) => {
				// 使用现有的消息处理逻辑
				_this.messageProcess(rawMessage);
			});

			/**
			 * 订阅深度思考消息
			 * 专门处理深度思考相关的消息
			 */
			_this.deepThinkUnsubscribe = _this.wsManager.subscribe('deepthink', (payload) => {
				console.log('收到深度思考消息', payload);
				// 可以在这里添加专门的深度思考消息处理逻辑
			});

			/**
			 * WebSocket连接断开事件
			 * 连接断开时的清理工作
			 */
			_this.wsManager.onDisconnected((eventData) => {
				console.log('WebSocket连接已断开', {
					code: eventData.code,
					reason: eventData.reason,
					connectionId: eventData.connectionId
				});

				// 更新连接状态
				_this.is_open_socket = false;

				// 停止当前回答（防止界面卡在回答状态）
				_this.stopAnswer();

				// 触发自定义连接断开事件
				_this.$emit('websocket-disconnected', {
					code: eventData.code,
					reason: eventData.reason,
					connectionId: eventData.connectionId
				});
			});

			/**
			 * WebSocket连接错误事件
			 * 处理连接过程中的各种错误
			 */
			_this.wsManager.onError((eventData) => {
				console.error('WebSocket连接发生错误', {
					error: eventData.errMsg || '未知错误',
					connectionId: eventData.connectionId,
					timestamp: eventData.timestamp
				});

				// 更新连接状态
				_this.is_open_socket = false;

				// 停止当前回答
				_this.stopAnswer();

				// 触发自定义错误事件
				_this.$emit('websocket-error', {
					error: eventData.errMsg || '连接错误',
					connectionId: eventData.connectionId
				});
			});

			// ==================== 重连相关事件 ====================

			/**
			 * WebSocket重连成功事件
			 * 自动重连成功后的处理
			 */
			_this.wsManager.onReconnected((result) => {
				console.log('WebSocket自动重连成功', {
					attempts: result.attempts,
					reconnectTime: result.reconnectTime
				});

				// 隐藏手动重连按钮
				_this.resizeBtnShow = false;

				// 显示重连成功提示
				showToast('在重连中...');

				// 触发重连成功事件
				_this.$emit('websocket-reconnected', {
					attempts: result.attempts,
					reconnectTime: result.reconnectTime
				});
			});

			/**
			 * WebSocket重连开始事件
			 * 开始重连时的UI反馈
			 */
			_this.wsManager.onReconnecting((result) => {
				console.log('WebSocket开始重连', {
					attempts: result.attempts,
					delay: result.delay
				});

				// 可以在这里显示重连进度
				_this.$emit('websocket-reconnecting', result);
			});

			// ==================== 高级功能事件 ====================

			/**
			 * 心跳超时事件
			 * 心跳检测超时可能表示网络不稳定
			 */
			const heartbeatTimeoutUnsubscribe = _this.wsManager._addEventListener('heartbeatTimeout', (eventData) => {
				console.warn('WebSocket心跳检测超时', {
					timeout: eventData.timeout,
					lastHeartbeatTime: eventData.lastHeartbeatTime
				});

				// 可以在这里添加网络状态提示
				// showToast('网络连接不稳定', 'none');
			});

			/**
			 * 连接状态变化事件
			 * 监听连接状态的实时变化
			 */
			const stateChangeUnsubscribe = _this.wsManager._addEventListener('stateChange', (eventData) => {
				console.log('WebSocket状态变化', {
					connected: eventData.connected,
					reason: eventData.reason,
					timestamp: eventData.timestamp
				});

				// 触发状态变化事件（供外部组件监听）
				_this.$emit('websocket-status-change', eventData);
			});

			// 保存取消订阅函数以供组件销毁时使用
			_this.heartbeatTimeoutUnsubscribe = heartbeatTimeoutUnsubscribe;
			_this.stateChangeUnsubscribe = stateChangeUnsubscribe;

			console.log('WebSocket事件监听器设置完成');
		},

		/**
		 * 处理WebSocket初始化错误
		 * 统一处理连接初始化过程中的各种错误
		 * @param {Error} error 错误对象
		 */
		handleWebSocketInitError(error) {
			const _this = this;

			console.error('WebSocket连接初始化失败', error);

			// 显示重连按钮
			_this.resizeBtnShow = true;

			// 停止等待动画
			_this.stopAnswer(false, 'WebSocket初始化失败');

			// 显示错误提示
			const errorMessage = error.message || '连接初始化失败';

			// 根据错误类型显示不同提示
			let userMessage = '连接失败，请重试';
			if (errorMessage.includes('onClose')) {
				userMessage = 'Mock模式配置错误，请检查代码';
			} else if (errorMessage.includes('token')) {
				userMessage = '身份验证失败，请重新登录';
			} else if (errorMessage.includes('网络')) {
				userMessage = '网络连接异常，请检查网络';
			}

			showToast(userMessage);

			// 触发初始化失败事件
			_this.$emit('websocket-init-failed', {
				error: errorMessage,
				userMessage,
				timestamp: Date.now()
			});
		},

		/**
		 * 更新消息统计信息
		 * 用于监控对话活跃度和性能
		 */
		updateMessageStats() {
			// 这里可以添加消息统计逻辑
			// 例如：记录消息数量、平均响应时间等
			if (this.wsManager && this.wsManager.enableConnectionStats) {
				const stats = this.wsManager.getStatus().stats;
				if (stats) {
					// 可以将统计信息存储到vuex或者发送到监控系统
					console.log('WebSocket消息统计', {
						totalMessages: stats.totalMessages,
						totalConnections: stats.totalConnections,
						totalReconnections: stats.totalReconnections
					});
				}
			}
		},
		// 处理返回消息（兼容mock和正式模式）
		messageProcess(res) {
			const _this = this;
			clearInterval(_this.timer);
			_this.timerShow = false;

			let lastIndex = _this.recordList.length - 1;
			// 添加一个空消息
			if (_this.recordList[lastIndex].type !== 2) {
				_this.recordList.push({
					createTime: getCurrentDateTime(),
					type: 2,
					content: ''
				});
				lastIndex += 1;
			}

			if (_this.recordList[lastIndex].content.includes(_this.config.message.answerWait)) {
				_this.recordList[lastIndex].content = '';
			}

			// 需要换类型和转json的数据类型
			const tagJsonList = ['[JSON]'];
			const tagList = ['[TEXT]', '[DONE]', '[SEEK]'];
			const realTagList = ['[TEXT]', '[CHARTDATA]', '[DONE]']; // 正式版本的标签

			// 结束深度思考执行的方法
			const closeDeepThink = () => {
				if (_this.deepThink) {
					_this.deepThink = false;
					clearInterval(_this.deepThinkSetTimes);
					_this.recordList[lastIndex].deepThinkTime = _this.deepThinkTime;
					// 深度思考结束后，保持状态为true以显示思考内容
					_this.recordList[lastIndex].deepThinkStatus = true;
				}
			};

			if (_this.mockMode) {
				// Mock模式的消息处理（支持深度思考等高级功能）
				if (res.data == tagList[0]) {
					_this.answerChart = false;
					closeDeepThink();
				} else if (tagJsonList.includes(res.data)) {
					// json类型数据
					_this.answerChart = true;
					closeDeepThink();
				} else if (res.data == tagList[1]) {
					// 结束
					_this.answerChart = false;
					_this.answerStatus = false;
					_this.deepThink = false;
					closeDeepThink();

					// 微信小程序做特殊处理
					// #ifdef MP-WEIXIN
					if (_this.answerImgSrc) {
						_this.recordList[lastIndex].content = _this.recordList[lastIndex].content.replace('......', _this.answerImgSrc);
						_this.answerImgSrc = '';
					}
					// #endif
				} else if (res.data == tagList[2]) {
					// 深度思考开始 - [SEEK]标签
					_this.deepThink = true;
					_this.recordList[lastIndex].deepThinkStatus = true;
					_this.recordList[lastIndex].deepThinkContent = ''; // 初始化深度思考内容
					_this.deepThinkTime = 0;
					_this.deepThinkSetTimes = setInterval(() => {
						_this.deepThinkTime++;
					}, 1000);
				} else {
					if (_this.deepThink) {
						const deepThinkContentStr = _this.recordList[lastIndex].deepThinkContent || '';
						// 深度思考内容累积
						_this.recordList[lastIndex].deepThinkContent = deepThinkContentStr + res.data;
					} else if (_this.answerChart) {
						let jsonData = {};
						let len = 0;

						try {
							jsonData = JSON.parse(res.data);
							if (typeof jsonData == 'object' && Object.keys(jsonData).length) {
								len = Object.keys(jsonData).length;
							}
						} catch (error) {
							console.log(error);
						}

						if (len) {
							// 确认数据追加类型
							let { type, dataStr } = jsonData;
							if (type && jsonData && !['[]', '{}'].includes(jsonData)) {
								console.log('当前数据类型', type);
								_this.recordList[lastIndex].contentType = type;
								if (type == 'image') {
									// 图片类型
									_this.recordList[lastIndex].content = dataStr;
								} else {
									_this.recordList[lastIndex].contentAppendData = dataStr;
								}
							}
						}
					} else {
						// 文本处理逻辑（包含图片生成动画）
						_this.processTextContent(res, lastIndex);
					}
				}
			} else {
				// 正式模式的消息处理
				if (res.data == realTagList[0]) {
					_this.answerChart = false;
				} else if (res.data == realTagList[1]) {
					_this.answerChart = true;
				} else if (res.data == realTagList[2]) {
					// 结束
					_this.answerChart = false;
					_this.answerStatus = false;

					// 微信小程序做特殊处理
					// #ifdef MP-WEIXIN
					if (_this.answerImgSrc) {
						_this.recordList[lastIndex].content = _this.recordList[lastIndex].content.replace('......', _this.answerImgSrc);
						_this.answerImgSrc = '';
					}
					// #endif
				} else {
					if (_this.answerChart) {
						let jsonData = {};
						let len = 0;
						try {
							jsonData = JSON.parse(res.data);
							if (typeof jsonData == 'object' && Object.keys(jsonData).length) {
								len = Object.keys(jsonData).length;
							}
						} catch (error) {
							console.log(error);
						}
						console.log('数据', jsonData, typeof jsonData);
						if (len) {
							// 确认数据追加类型
							let { chartType, chartData } = jsonData;
							if (chartType && chartData && !['[]', '{}'].includes(chartData)) {
								console.log('当前数据类型', chartType);
								_this.recordList[lastIndex].contentType = 'chart_' + chartType;
								_this.recordList[lastIndex].contentAppendData = chartData;
							}
						}
					} else {
						// 文本处理逻辑
						_this.processTextContent(res, lastIndex);
					}
				}
			}

			_this.debounceToBottom();
			// v2 必须强制更新视图，否则无法监听变化
			_this.$set(_this.recordList, lastIndex, _this.recordList[lastIndex]);
		},
		// 处理文本内容（图片生成动画等）
		processTextContent(res, lastIndex) {
			const _this = this;
			// 微信小程序会疯狂抖动
			// #ifndef MP-WEIXIN
			// 图片链接处理优化
			if (res.data.includes('[](')) {
				// 缓存
				_this.answerImgSrc = _this.answerImgSrc + res.data;
				_this.answerImgSrcShow = true;
			} else if (res.data.includes(')')) {
				const imgSrc = _this.answerImgSrc + res.data;
				let loadingStr = '生成中⠙';
				if (_this.recordList[lastIndex].content.includes('生成中⠙')) {
					loadingStr = '生成中⠙';
				} else if (_this.recordList[lastIndex].content.includes('生成中⠸')) {
					loadingStr = '生成中⠸';
				} else if (_this.recordList[lastIndex].content.includes('生成中⠴')) {
					loadingStr = '生成中⠴';
				} else {
					loadingStr = '生成中⠇';
				}

				_this.recordList[lastIndex].content = _this.recordList[lastIndex].content.replace(loadingStr, imgSrc);
				_this.answerImgSrc = '';
				_this.answerImgSrcShow = false;
			} else {
				if (_this.answerImgSrcShow) {
					let textStr = _this.recordList[lastIndex].content;
					if (!_this.recordList[lastIndex].content.includes('生成中')) {
						textStr = textStr + '生成中⠙';
					} else {
						if (_this.recordList[lastIndex].content.includes('生成中⠙')) {
							textStr = textStr.replace('生成中⠙', '生成中⠸');
						} else if (_this.recordList[lastIndex].content.includes('生成中⠸')) {
							textStr = textStr.replace('生成中⠸', '生成中⠴');
						} else if (_this.recordList[lastIndex].content.includes('生成中⠴')) {
							textStr = textStr.replace('生成中⠴', '生成中⠇');
						} else {
							textStr = textStr.replace('生成中⠇', '生成中⠙');
						}
					}
					// 缓存
					_this.answerImgSrc = _this.answerImgSrc + res.data;
					_this.recordList[lastIndex].content = textStr;
				} else {
					_this.recordList[lastIndex].content = _this.recordList[lastIndex].content + res.data;
				}
			}
			// #endif

			// 微信小程序做特殊处理
			// #ifdef MP-WEIXIN
			// 图片链接处理优化
			if (res.data.includes('[](')) {
				// 缓存
				_this.answerImgSrc = _this.answerImgSrc + res.data;
				_this.answerImgSrcShow = true;
			} else if (res.data.includes(')')) {
				let loadingStr = '生成中⠙';
				if (_this.recordList[lastIndex].content.includes('生成中⠙')) {
					loadingStr = '生成中⠙';
				} else if (_this.recordList[lastIndex].content.includes('生成中⠸')) {
					loadingStr = '生成中⠸';
				} else if (_this.recordList[lastIndex].content.includes('生成中⠴')) {
					loadingStr = '生成中⠴';
				} else {
					loadingStr = '生成中⠇';
				}

				_this.recordList[lastIndex].content = _this.recordList[lastIndex].content.replace(loadingStr, '......');

				// 缓存
				_this.answerImgSrc = _this.answerImgSrc + res.data;
				_this.answerImgSrcShow = false;
			} else {
				if (_this.answerImgSrcShow) {
					let textStr = _this.recordList[lastIndex].content;
					if (!_this.recordList[lastIndex].content.includes('生成中')) {
						textStr = textStr + '生成中⠙';
					} else {
						if (_this.recordList[lastIndex].content.includes('生成中⠙')) {
							textStr = textStr.replace('生成中⠙', '生成中⠸');
						} else if (_this.recordList[lastIndex].content.includes('生成中⠸')) {
							textStr = textStr.replace('生成中⠸', '生成中⠴');
						} else if (_this.recordList[lastIndex].content.includes('生成中⠴')) {
							textStr = textStr.replace('生成中⠴', '生成中⠇');
						} else {
							textStr = textStr.replace('生成中⠇', '生成中⠙');
						}
					}
					// 缓存
					_this.answerImgSrc = _this.answerImgSrc + res.data;
					_this.recordList[lastIndex].content = textStr;
				} else {
					_this.recordList[lastIndex].content = _this.recordList[lastIndex].content + res.data;
				}
			}
			// #endif
		},
		/**
		 * 停止AI回答过程
		 * 清理回答状态、停止动画、移除占位消息，并可选择性地通知服务器
		 *
		 * @param {Boolean} notifyServer 是否通知服务器停止回答，默认false
		 * @param {String} reason 停止原因，用于日志记录
		 */
		stopAnswer(notifyServer = false, reason = '用户终止') {
			const _this = this;

			console.log('正在停止AI回答', {
				reason,
				notifyServer,
				hasTimer: !!_this.timer,
				answerStatus: _this.answerStatus
			});

			// 停止等待动画定时器
			if (_this.timer) {
				clearInterval(_this.timer);
				_this.timer = null;
			}

			// 重置回答状态
			_this.answerStatus = false;
			_this.timerShow = false;

			// 移除等待消息（包含等待文本的占位消息）
			const waitMessage = _this.config.message.answerWait;
			_this.recordList = _this.recordList.filter((item) => {
				// 移除包含等待文本的消息或标记为占位的消息
				return !(item.content?.indexOf(waitMessage) === 0 || item.isPlaceholder);
			});

			// 可选：通知服务器停止当前回答
			if (notifyServer && _this.wsManager && _this.is_open_socket) {
				try {
					const stopMessage = {
						type: 'stop',
						reason: reason,
						timestamp: Date.now()
					};

					_this.wsManager.send(JSON.stringify(stopMessage)).then(() => {
						console.log('已通知服务器停止回答');
					}).catch((error) => {
						console.warn('通知服务器停止回答失败', error);
					});
				} catch (error) {
					console.warn('发送停止指令失败', error);
				}
			}

			// 清理深度思考相关定时器
			if (_this.deepThinkSetTimes) {
				clearInterval(_this.deepThinkSetTimes);
				_this.deepThinkSetTimes = null;
			}

			// 触发停止回答事件
			_this.$emit('answer-stopped', {
				reason,
				notifyServer,
				timestamp: Date.now()
			});

			console.log('AI回答已停止');
		},
		/**
		 * 关闭WebSocket连接
		 * 在页面离开或组件销毁时调用，清理连接和相关定时器
		 */
		closeSocket() {
			const _this = this;

			// 使用WebSocket工具类关闭连接
			if (_this.wsManager) {
				_this.wsManager.close();
				_this.wsManager = null;
				_this.is_open_socket = false;
				console.log('WebSocket连接已关闭');
			}

			// 清理相关定时器，防止内存泄漏
			if (_this.jumpTimer) {
				clearInterval(_this.jumpTimer);        // 清理心跳定时器（兼容旧代码）
				_this.jumpTimer = null;
			}
			if (_this.deepThinkSetTimes) {
				clearInterval(_this.deepThinkSetTimes);  // 清理深度思考计时器
				_this.deepThinkSetTimes = null;
			}
			if (_this.timer) {
				clearInterval(_this.timer);            // 清理回答动画定时器
				_this.timer = null;
			}
		},
		// ==================== 消息发送相关方法 ====================

		/**
		 * 发送消息到AI智能体
		 * 执行完整的验证流程后，将用户消息发送给AI并开始等待回复
		 *
		 * 处理流程：
		 * 1. 前置验证（智能体ID、token、消息内容、发送状态等）
		 * 2. 消息预处理（清空输入框、隐藏推荐等）
		 * 3. 添加用户消息到对话记录
		 * 4. 发送消息到WebSocket服务器
		 * 5. 创建AI回答占位并启动等待动画
		 * 6. 错误处理和状态恢复
		 */
		async sendMessage() {
			const _this = this;

			// ==================== 前置验证阶段 ====================

			// 验证消息发送的前置条件
			const validationResult = _this.validateSendConditions();
			if (!validationResult.isValid) {
				if (validationResult.showToast) {
					showToast(validationResult.message);
				}
				return;
			}

			// ==================== 消息预处理阶段 ====================

			try {
				// 隐藏推荐消息（发送消息后不再显示推荐）
				_this.hideRecommendedMessages();

				// 获取并预处理消息内容
				const messageData = _this.preprocessMessage();

				// 添加用户消息到对话记录
				_this.addUserMessageToRecord(messageData.content);

				// 滚动到底部显示最新消息
				_this.toBottom();

				// 设置AI回答状态，防止重复发送
				_this.answerStatus = true;

				// 记录发送开始时间（用于统计）
				const sendStartTime = Date.now();

				// ==================== 消息发送阶段 ====================

				// 构建发送选项
				const sendOptions = _this.buildSendOptions();

				// Mock模式：直接模拟消息发送和回复
				if (_this.mockMode) {
					console.log('🎭 Mock模式：模拟消息发送和AI回复', {
						content: messageData.content,
						options: sendOptions
					});

					// 直接使用本地的Mock消息处理方法
					_this.sendMockMessageLocal(messageData.content, sendOptions);

					console.log('✅ Mock消息发送完成');
				} else {
					// 正式模式：确保WebSocket管理器存在
					if (!_this.wsManager) {
						throw new Error('WebSocket管理器未初始化，请稍后重试');
					}

					// 使用企业级WebSocket管理器发送AI消息
					await _this.wsManager.sendAIMessage(messageData.content, sendOptions);
				}

				// 记录发送成功
				const sendTime = Date.now() - sendStartTime;
				console.log('消息发送成功', {
					messageLength: messageData.content.length,
					sendTime,
					options: sendOptions,
					mockMode: _this.mockMode
				});

				// 创建AI回答占位消息并开始等待动画
				_this.createAnswerPlaceholder();

				// 触发消息发送成功事件
				_this.$emit('message-sent', {
					content: messageData.content,
					sendTime,
					agentId: _this.agentIdAgent,
					timestamp: Date.now()
				});

			} catch (error) {
				// ==================== 错误处理阶段 ====================
				_this.handleSendMessageError(error);
			}
		},

		/**
		 * 验证消息发送的前置条件
		 * 检查智能体ID、token、消息内容、连接状态等
		 * @returns {Object} 验证结果 { isValid: boolean, message: string, showToast: boolean }
		 */
		validateSendConditions() {
			const _this = this;

			// 验证智能体ID（Mock模式可跳过）
			if (!_this.agentIdAgent && !_this.mockMode) {
				return {
					isValid: false,
					message: '必须传入智能体ID',
					showToast: true
				};
			}

			// Mock模式下确保智能体ID不为空
			if (_this.mockMode && !_this.agentIdAgent) {
				_this.agentIdAgent = 'mock-agent-id';
				console.log('Mock模式：自动设置智能体ID');
			}

			// 正式模式：验证用户token
			if (!_this.mockMode) {
				if (typeof getToken !== 'function') {
					return {
						isValid: false,
						message: 'getToken必须是函数类型',
						showToast: true
					};
				}

				if (!getToken()) {
					return {
						isValid: false,
						message: '必须配置有效的用户token',
						showToast: true
					};
				}
			}

			// 验证消息内容不为空
			if (!_this.message || _this.message.trim() === '') {
				return {
					isValid: false,
					message: '消息内容不能为空',
					showToast: false  // 空消息不显示提示
				};
			}

			// 防止重复发送（AI正在回答时）
			if (_this.answerStatus) {
				return {
					isValid: false,
					message: '请等待当前对话完成',
					showToast: true
				};
			}

			// Mock模式下跳过WebSocket连接状态检查
			if (_this.mockMode) {
				// Mock模式下直接通过验证
				console.log('🎭 Mock模式验证通过：跳过连接状态检查', {
					mockMode: _this.mockMode,
					is_open_socket: _this.is_open_socket,
					hasWsManager: !!_this.wsManager
				});
				return {
					isValid: true,
					message: '',
					showToast: false
				};
			}

			// 正式模式：检查WebSocket连接状态
			if (!_this.is_open_socket) {
				console.info('发送消息时WebSocket已断开，尝试重连');
				// 异步尝试重连，不阻塞当前发送
				_this.wxResize().catch(error => {
					console.error('重连失败:', error);
				});

				return {
					isValid: false,
					message: '连接已断开，正在尝试重连...',
					showToast: true
				};
			}

			// 所有验证通过
			return {
				isValid: true,
				message: '',
				showToast: false
			};
		},

		/**
		 * 隐藏推荐消息
		 * 使用Vue过渡动画平滑隐藏推荐消息
		 */
		hideRecommendedMessages() {
			if (this.showRecommendedMessages) {
				this.showRecommendedMessages = true; // 确保过渡开始
				this.$nextTick(() => {
					this.showRecommendedMessages = false; // 触发Vue的过渡更新
				});
			}
		},

		/**
		 * 预处理消息内容
		 * 获取、清理和验证用户输入的消息
		 * @returns {Object} 消息数据 { content: string, originalLength: number }
		 */
		preprocessMessage() {
			const _this = this;

			// 获取原始消息内容
			const originalMessage = _this.message;
			const originalLength = originalMessage.length;

			// 清理消息内容（去除首尾空格）
			const cleanedMessage = originalMessage.trim();

			// 清空输入框和相关状态
			_this.message = null;
			_this.microphone = false;

			// 返回处理后的消息数据
			return {
				content: cleanedMessage,
				originalLength,
				timestamp: Date.now()
			};
		},

		/**
		 * 添加用户消息到对话记录
		 * 将用户消息格式化后添加到recordList中
		 * @param {String} messageContent 消息内容
		 */
		addUserMessageToRecord(messageContent) {
			this.recordList.push({
				createTime: getCurrentDateTime(),
				type: 1,                    // 类型1表示用户消息
				content: messageContent,
				contentAppendData: null,
				messageId: this.generateMessageId(),  // 生成唯一消息ID
				timestamp: Date.now()
			});
		},

		/**
		 * 构建消息发送选项
		 * 根据当前模式和用户选择构建发送选项
		 * @returns {Object} 发送选项
		 */
		buildSendOptions() {
			const _this = this;

			const options = {
				// 基础选项
				timeout: 30000,  // 30秒超时
				priority: false, // 普通优先级
			};

			// 检查是否启用深度思考（工具栏功能）
			const isDeepThinkActive = Array.isArray(_this.activeList) && _this.activeList.includes(1);
			const isWebSearchActive = Array.isArray(_this.activeList) && _this.activeList.includes(2);

			options.deepThink = isDeepThinkActive;
			options.webSearch = isWebSearchActive;

			return options;
		},

		/**
		 * 创建AI回答占位消息并启动等待动画
		 * 在消息发送后立即创建占位消息，显示等待动画
		 */
		createAnswerPlaceholder() {
			const _this = this;

			// 创建AI回答占位消息
			_this.recordList.push({
				createTime: getCurrentDateTime(),
				type: 2,                    // 类型2表示AI回答
				content: '',
				messageId: _this.generateMessageId(),
				timestamp: Date.now(),
				isPlaceholder: true         // 标记为占位消息
			});

			const lastIndex = _this.recordList.length - 1;
			const waitMessage = _this.config.message.answerWait;

			// 启动等待回答的动画效果
			_this.timer = setInterval(() => {
				_this.timerShow = true;

				let content = _this.recordList[lastIndex].content;
				content = content.replace(waitMessage, '');

				// 创建动态等待效果（. -> .. -> ... -> . ...）
				if (content.length >= 3) {
					content = waitMessage + '.';
				} else {
					content = waitMessage + content + '.';
				}

				_this.recordList[lastIndex].content = content;
			}, 300);

			console.log('AI回答占位消息已创建，等待动画已启动');
		},

		/**
		 * 处理消息发送错误
		 * 统一处理发送过程中的各种错误
		 * @param {Error} error 错误对象
		 */
		handleSendMessageError(error) {
			const _this = this;

			console.error('消息发送失败', {
				error: error.message || error,
				agentId: _this.agentIdAgent,
				timestamp: Date.now()
			});

			// 恢复发送状态
			_this.answerStatus = false;

			// 停止等待动画
			if (_this.timer) {
				clearInterval(_this.timer);
				_this.timer = null;
				_this.timerShow = false;
			}

			// 移除可能创建的占位消息
			_this.removeLastPlaceholderMessage();

			// 根据错误类型显示不同的提示消息
			let errorMessage = '消息发送失败，请重试';
			if (error.message) {
				if (error.message.includes('timeout')) {
					errorMessage = '发送超时，请检查网络连接';
				} else if (error.message.includes('连接')) {
					errorMessage = '连接异常，请稍后重试';
				} else if (error.message.includes('队列')) {
					errorMessage = '消息队列已满，请稍后重试';
				}
			}

			showToast(errorMessage);

			// 触发消息发送失败事件
			_this.$emit('message-send-failed', {
				error: error.message || error,
				timestamp: Date.now()
			});
		},

		/**
		 * 移除最后一个占位消息
		 * 在发送失败时清理可能创建的占位消息
		 */
		removeLastPlaceholderMessage() {
			const lastMessage = this.recordList[this.recordList.length - 1];
			if (lastMessage && lastMessage.isPlaceholder) {
				this.recordList.pop();
				console.log('已移除占位消息');
			}
		},

		/**
		 * 生成唯一的消息ID
		 * 用于标识和跟踪单条消息
		 * @returns {String} 唯一消息ID
		 */
		generateMessageId() {
			return `msg_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
		},

		/**
		 * Mock模式本地消息发送处理
		 * 在Mock模式下直接处理消息发送和模拟回复，无需WebSocket连接
		 * @param {String} message 要发送的消息内容
		 * @param {Object} options 发送选项，包括deepThink、webSearch等
		 */
		sendMockMessageLocal(message, options = {}) {
			const _this = this;

			console.log('🎭 Mock模式本地消息处理开始', {
				message: message.substring(0, 50) + '...',
				deepThink: options.deepThink,
				webSearch: options.webSearch
			});

			// 生成Mock回复数据
			const mockResponse = _this.generateMockResponse(message, options);

			// 模拟网络延迟和流式回复
			let messageIndex = 0;
			const sendNextMessage = () => {
				if (messageIndex < mockResponse.messages.length) {
					const messageData = mockResponse.messages[messageIndex];

					// 模拟延迟
					setTimeout(() => {
						console.log(`🎭 Mock回复 ${messageIndex + 1}/${mockResponse.messages.length}:`, messageData);

						// 直接调用消息处理方法
						_this.messageProcess({ data: messageData });

						messageIndex++;
						sendNextMessage(); // 递归发送下一条消息
					}, mockResponse.delay);
				} else {
					console.log('✅ Mock消息流式回复完成');
				}
			};

			// 开始发送消息流
			sendNextMessage();
		},

		/**
		 * 生成模拟响应数据（Mock模式专用）
		 * 根据用户输入和配置选项，智能生成模拟的AI回答流
		 *
		 * @param {String} message 用户输入的消息内容
		 * @param {Object} options 配置选项
		 * @param {Boolean} options.deepThink 是否启用深度思考模式
		 * @param {Boolean} options.webSearch 是否启用联网搜索
		 * @returns {Object} 包含消息流、延迟时间和总数的对象
		 */
		generateMockResponse(message, options = {}) {
			// 深度思考内容
			const deepThinkContentList = [
				'[SEEK]', "首", "先", "，", "我", "需", "要", "理", "解", "用", "户", "的", "具", "体", "需", "求", "。",
				"根", "据", "用", "户", "之", "前", "的", "对", "话", "历", "史", "，", "他", "曾", "提", "到", "过", "「", "深", "度", "思", "考", "的", "流", "式",
				"回", "答", "数", "组", "」", "，", "并", "希", "望", "结", "合", "动", "态", "生", "成", "和", "展", "示", "思", "考", "过", "程",
				"的", "数", "据", "结", "构", "。",
				"\n\n", "接", "下", "来", "，", "我", "需", "要", "查", "看", "用", "户", "提", "供", "的", "搜", "索", "结", "果", "。", "用",
				"户", "提", "供", "了", "多", "个", "网", "页", "，", "其", "中", "网", "页", "4", "和", "网", "页", "5", "提", "到", "了", "D", "e",
				"e", "p", "S", "e", "e", "k", "的", "深", "度", "思", "考", "功", "能", "，", "特", "别", "是", "网", "页", "4", "详", "细",
				"介", "绍", "了", "D", "e", "e", "p", "S", "e", "e", "k", "-", "R", "1", "模", "型", "的", "思", "维", "链", "生", "成",
				"过", "程", "，", "包", "括", "如", "何", "分", "步", "骤", "展", "示", "思", "考", "路", "径", "。", "\n\n", '[TEXT]'
			];

			// 基础回复内容
			let contentMessages = [];
			let jsonData = null;
			let startTag = '[TEXT]';
			let endTag = '[DONE]';

			// 根据消息内容生成不同类型的回复
			if (message.includes('活动')) {
				const data = {
					type: 'activity',
					dataStr: '[{"id":1,"name":"双111活动"},{"id":2,"name":"双22活动2"},{"id":3,"name":"双22活动23这是活动名称这是活动名称"}]'
				};
				contentMessages = ["好", "的", "，", "这", "是", "活", "动", "："];
				jsonData = JSON.stringify(data);
				startTag = '[JSON]';
			} else if (message.includes('优惠券')) {
				const data = {
					type: 'coupon',
					dataStr: '[{"id":1,"price":3000,"fullPrice":1000,"name":"满减券","deadlineStart":"2024/10/12","deadlineEnd":"2024/11/12"},{"id":2,"price":3000,"fullPrice":1000,"name":"折扣券","deadlineStart":"2024/10/12","deadlineEnd":"2024/11/12"}]'
				};
				contentMessages = ["好", "的", "，", "这", "是", "优", "惠", "券", "："];
				jsonData = JSON.stringify(data);
				startTag = '[JSON]';
			} else if (message.includes('商品')) {
				const data = {
					type: 'goods',
					dataStr: '[{"id":1,"price":3000,"url":"https://img.alicdn.com/bao/uploaded/i3/2055770076/O1CN01jEkYK61CQr2Na3EO7_!!0-saturn_solar.jpg","name":"我是商品","desc":"好衣服你知道"}]'
				};
				contentMessages = ["好", "的", "，", "这", "是", "商", "品", "："];
				jsonData = JSON.stringify(data);
				startTag = '[JSON]';
			} else if (message.includes('图表')) {
				const data = {
					type: 'chart_1',
					dataStr: '[{"name":"一班","value":50},{"name":"二班","value":30},{"name":"三班","value":20},{"name":"四班","value":18},{"name":"五班","value":8}]'
				};
				contentMessages = ["好", "的", "，", "这", "是", "图", "表", "："];
				jsonData = JSON.stringify(data);
				startTag = '[JSON]';
			} else if (message.includes('表格')) {
				const data = {
					type: 'tables',
					dataStr: '{"tableColumns": [{ "title": "苹果","key": "a","align": "center" },{  "title": "橘子", "key": "b", "align": "center"}],"tableData": [{"a": "10000元/斤","b": "200元/斤"},{"a": "2200元/斤","b": "2300元/斤"}]}'
				};
				contentMessages = ["好", "的", "，", "这", "是", "表", "格", "："];
				jsonData = JSON.stringify(data);
				startTag = '[JSON]';
			} else if (message.includes('图片')) {
				contentMessages = [
					'已', '经', '为', '您', '生', '成', '了', '一', '张', '活', '泼', '可', '爱', '的', '小', '女', '孩', '的', '图',
					'片', '。', ' ![](https://img-baofun.zhhainiao.com/pcwallpaper',
					'_ugc/static/50706fe64cbbdddc2c8c99d27eb64d4d.jpeg',
					'?x-oss-process=image%2fresize%2cm_lfit%2cw', '_3840%2ch_2160)',
					'希', '望', '这', '张', '图', '片', '符', '合', '您', '的', '期', '望', '！',
					'如', '果', '有', '任', '何', '其', '他', '需', '求', '或', '想', '要', '调', '整', '的', '地', '方', '，',
					'请', '随', '时', '告', '诉', '我', '。'
				];
			} else {
				contentMessages = [
					"可", "以", "问", ":", "活", "动", "、", "优", "惠", "券", "、", "商", "品", "、",
					"图", "表", "、", "表", "格", "、", "图", "片", "。", "这", "些", "关", "键", "词", "触", "发",
					"对", "应", "的", "回", "答", "，", "让", "你", "体", "验", "M", "o", "c", "k", "模", "式", "！"
				];
			}

			// 构建完整的消息流
			let allMessages = [];

			// 如果启用深度思考，先添加深度思考内容
			if (options.deepThink) {
				console.log('🧠 启用深度思考模式');
				allMessages = [...deepThinkContentList];
			}

			// 添加标准回复内容
			if (jsonData) {
				// JSON数据类型回复
				allMessages = [
					...allMessages,
					'[TEXT]',
					...contentMessages,
					startTag,
					jsonData,
					endTag
				];
			} else {
				// 纯文本回复
				allMessages = [
					...allMessages,
					startTag,
					...contentMessages,
					endTag
				];
			}

			return {
				messages: allMessages,
				delay: options.deepThink ? 200 : 105,  // 深度思考模式稍慢一些
				totalCount: allMessages.length
			};
		},
		setResponse(e, index) {
			let {
				type
			} = e;
			console.log('当前类型是', type, '：下标：', index);
			switch (type) {
				case 'send':
					this.setSend(index);
					break;
				case 'resize':
					this.setNewMessage(index);
					break;
				default:
					break;
			}
		},
		setSend() {
			console.log('跳转页面');
			showToast('跳转页面');
		},

		/**
		 * 手动重连WebSocket连接
		 * 响应用户点击重连按钮或程序触发的手动重连请求
		 *
		 * 功能特性：
		 * - 重置重连计数器，避免受自动重连次数限制
		 * - 支持wsManager不存在时的完全重新初始化
		 * - 提供详细的用户反馈和错误处理
		 * - 异步执行，不阻塞UI操作
		 *
		 * @returns {Promise} 重连结果Promise
		 */
		async wxResize() {
			const _this = this;

			console.log('开始执行手动重连...', {
				hasWsManager: !!_this.wsManager,
				currentConnectStatus: _this.is_open_socket,
				timestamp: Date.now()
			});

			try {
				// 隐藏重连按钮，显示重连中状态
				_this.resizeBtnShow = false;

				// 重连开始时间统计
				const reconnectStartTime = Date.now();

				if (_this.wsManager) {
					// WebSocket管理器存在，使用其重连功能
					console.log('使用现有WebSocket管理器重连...');
					await _this.wsManager.reconnect();

					// 重连成功统计
					const reconnectTime = Date.now() - reconnectStartTime;
					console.log('WebSocket手动重连成功', { reconnectTime });

					// 显示成功提示
					showToast('连接已恢复');

					// 触发手动重连成功事件
					_this.$emit('manual-reconnect-success', {
						reconnectTime,
						timestamp: Date.now()
					});

				} else {
					// Mock模式下不进行真实重连
					if (_this.mockMode) {
						console.log('Mock模式：跳过WebSocket重新初始化');
						showToast('Mock模式无需重连');
						return;
					}

					// WebSocket管理器不存在，完全重新初始化
					console.log('WebSocket管理器不存在，执行完全重新初始化...');
					await _this.connectSocketInit();

					// 重新初始化成功统计
					const initTime = Date.now() - reconnectStartTime;
					console.log('WebSocket重新初始化成功', { initTime });

					// 显示成功提示
					showToast('连接已建立');

					// 触发重新初始化成功事件
					_this.$emit('websocket-reinitialized', {
						initTime,
						timestamp: Date.now()
					});
				}

			} catch (error) {
				// 手动重连失败处理
				_this.handleManualReconnectError(error);
			}
		},

		/**
		 * 处理手动重连错误
		 * 统一处理手动重连过程中的各种错误情况
		 * @param {Error} error 重连错误对象
		 */
		handleManualReconnectError(error) {
			const _this = this;

			console.error('手动重连失败', {
				error: error.message || error,
				hasWsManager: !!_this.wsManager,
				timestamp: Date.now()
			});

			// 显示重连按钮，允许用户再次尝试
			_this.resizeBtnShow = true;

			// 根据错误类型显示不同的提示消息
			let errorMessage = '重连失败，请稍后重试';
			if (error.message) {
				if (error.message.includes('网络')) {
					errorMessage = '网络连接异常，请检查网络设置';
				} else if (error.message.includes('timeout')) {
					errorMessage = '连接超时，请重试';
				} else if (error.message.includes('token')) {
					errorMessage = '身份验证失败，请重新登录';
				}
			}

			showToast(errorMessage);

			// 触发手动重连失败事件
			_this.$emit('manual-reconnect-failed', {
				error: error.message || error,
				timestamp: Date.now()
			});
		},

		/**
		 * 获取WebSocket连接状态和详细信息
		 * 提供完整的连接状态信息，包括统计数据和诊断信息
		 *
		 * @param {Boolean} includeStats 是否包含统计信息，默认true
		 * @param {Boolean} includeDiagnostics 是否包含诊断信息，默认false
		 * @returns {Object} 连接状态对象
		 */
		getSocketStatus(includeStats = true, includeDiagnostics = false) {
			const _this = this;

			// 基础状态信息
			const baseStatus = {
				isConnected: _this.is_open_socket,
				mockMode: _this.mockMode,
				agentId: _this.agentIdAgent,
				historyId: _this.historyId,
				showReconnectBtn: _this.resizeBtnShow,
				answerStatus: _this.answerStatus
			};

			// 如果WebSocket管理器存在，获取详细状态
			if (_this.wsManager) {
				const managerStatus = _this.wsManager.getStatus();

				const detailedStatus = {
					...baseStatus,
					connectionId: managerStatus.connectionId,
					reconnectAttempts: managerStatus.reconnectAttempts,
					maxReconnectAttempts: managerStatus.maxReconnectAttempts,
					queueSize: managerStatus.queueSize,
					maxQueueSize: managerStatus.maxQueueSize,
					heartbeatInterval: managerStatus.heartbeatInterval,
					uptime: managerStatus.uptime
				};

				// 包含统计信息
				if (includeStats && managerStatus.stats) {
					detailedStatus.stats = managerStatus.stats;
				}

				// 包含诊断信息
				if (includeDiagnostics) {
					detailedStatus.diagnostics = _this.wsManager.getDiagnostics();
				}

				return detailedStatus;
			}

			// WebSocket管理器不存在时返回基础状态
			return {
				...baseStatus,
				connectionId: null,
				error: 'WebSocket管理器未初始化'
			};
		},

		/**
		 * 获取WebSocket诊断信息
		 * 用于调试和故障排查，提供详细的连接诊断数据
		 * @returns {Object} 诊断信息对象
		 */
		getSocketDiagnostics() {
			const _this = this;

			const diagnostics = {
				timestamp: Date.now(),
				component: {
					mockMode: _this.mockMode,
					agentId: _this.agentIdAgent,
					historyId: _this.historyId,
					isConnected: _this.is_open_socket,
					answerStatus: _this.answerStatus,
					showReconnectBtn: _this.resizeBtnShow,
					recordListLength: _this.recordList.length
				}
			};

			// 添加WebSocket管理器诊断信息
			if (_this.wsManager) {
				diagnostics.websocketManager = _this.wsManager.getDiagnostics();
			} else {
				diagnostics.websocketManager = {
					error: 'WebSocket管理器未初始化',
					initialized: false
				};
			}

			// 添加浏览器网络状态信息
			if (typeof navigator !== 'undefined') {
				diagnostics.network = {
					online: navigator.onLine,
					connection: navigator.connection ? {
						effectiveType: navigator.connection.effectiveType,
						downlink: navigator.connection.downlink,
						rtt: navigator.connection.rtt
					} : 'unavailable'
				};
			}

			return diagnostics;
		},

		/**
		 * 清理WebSocket相关资源
		 * 在组件销毁或需要完全重置时调用
		 * @param {Boolean} clearHistory 是否清理对话历史，默认false
		 */
		cleanupWebSocket(clearHistory = false) {
			const _this = this;

			console.log('开始清理WebSocket资源...', {
				clearHistory,
				hasWsManager: !!_this.wsManager,
				timestamp: Date.now()
			});

			// 停止当前回答动画（通知服务器停止）
			_this.stopAnswer(true, '组件销毁');

			// 清理WebSocket连接和相关资源
			if (_this.wsManager) {
				// 使用WebSocket管理器的清理方法
				_this.wsManager.cleanup();
				_this.wsManager.close();
				_this.wsManager = null;
			}

			// 重置连接状态
			_this.is_open_socket = false;
			_this.resizeBtnShow = false;
			_this.answerStatus = false;

			// 清理对话历史（可选）
			if (clearHistory) {
				_this.recordList = _this.config.guess ? [{ type: 3 }] : [];
				console.log('对话历史已清理');
			}

			// 清理组件相关定时器
			_this.clearComponentTimers();

			console.log('WebSocket资源清理完成');
		},

		/**
		 * 清理组件相关的所有定时器
		 * 防止内存泄漏
		 */
		clearComponentTimers() {
			const timers = [
				'timer',
				'jumpTimer',
				'deepThinkSetTimes'
			];

			timers.forEach(timerName => {
				if (this[timerName]) {
					clearInterval(this[timerName]);
					this[timerName] = null;
				}
			});
		},
		async setNewMessage(index) {
			clearInterval(this.timer);
			this.answerStatus = false;
			// this.recordList.splice(this.recordList.length - 1, 1);
			// this.message = this.recordList[this.recordList.length - 1].content;
			// //清除chatGPT的上下文内容
			// chatClearMessage({
			// 		agentId: this.agentIdAgent
			// 	})
			// 	.then((res) => {
			// 		this.setMessage();
			// 	})
			// 	.catch((err) => {
			// 		this.setMessage();
			// 	});
			// if(this.recordList.length < 2){
			// 	return;
			// }
			const _this = this;
			if (this.recordList.length < 2) {
				console.log('不允许对问候语提问');
				return;
			}
			let questionData = null;
			for (let i = index; i > 0; i--) {
				if (this.recordList[i].type == 1) {
					questionData = this.recordList[i];
					break;
				}
			}
			if (!questionData) {
				console.log('没有找到上一条提问的数据');
				return;
			}
			console.log('上一条提问的数据是', questionData);
			// if (_this.answerStatus) {
			// 	showToast('请等待当前对话完成');
			// 	return;
			// }
			if (_this.is_open_socket === false && !_this.mockMode) {
				console.info('发送消息,socket已关闭,进行重连');
				await _this.connectSocketInit();
			}
			// 1.可编辑上一条提问
			_this.message = questionData.content;
			_this.microphone = false;
			// 2.立即提问
			// let message = questionData.content;
			// // _this.message = null;
			// _this.microphone = false;
			// _this.recordList.push({
			// 	createTime: getCurrentDateTime(),
			// 	type: 1,
			// 	content: message
			// });
			// _this.toBottom();
			// _this.answerStatus = true;
			// _this.socketTask.send({
			// 	data: message,
			// 	async success() {
			// 		console.log('消息发送成功');
			// 	}
			// });
			// //模拟回答中动画
			// _this.recordList.push({
			// 	createTime: getCurrentDateTime(),
			// 	type: 2,
			// 	content: '.'
			// });
			// let lastIndex = _this.recordList.length - 1;

			// let msg = _this.config.message.answerWait;
			// _this.timer = setInterval(() => {
			// 	_this.timerShow = true;

			// 	let content = _this.recordList[lastIndex].content;
			// 	content = content.replace(msg, '');
			// 	if (content.length >= 3) {
			// 		content = msg + '.';
			// 	} else {
			// 		content = msg + content + '.';
			// 	}
			// 	_this.recordList[lastIndex].content = content;
			// }, 300);
		},
		// ==================== 工具方法 ====================

		/**
		 * 防抖显示欢迎信息
		 * WebSocket连接成功后延迟显示欢迎语，避免重复发送
		 */
		debounceShowGreeting: debounce(function () {
			let _this = this;
			if (this.is_open_socket) {
				let { message } = _this.config;
				// 检查是否需要发送欢迎语（配置中有欢迎语且历史记录中未发送过）
				if (message.greeting && !_this.recordList.some((item) => item.contentType == 'greeting')) {
					if (!_this.answerStatus) {
						_this.recordList.push({
							createTime: getCurrentDateTime(),
							type: 2,
							content: message.greeting,
							contentType: 'greeting'
						});
						console.log('欢迎信息已发送:', message.greeting);
					} else {
						console.log('AI正在回答中，欢迎信息暂不发送');
					}
				} else {
					console.log('无需发送欢迎信息（未配置或已发送）');
				}
			}
		}, 500),

		/**
		 * 防抖滚动到底部
		 * 避免频繁滚动操作
		 */
		debounceToBottom: debounce(function () {
			this.toBottom();
		}, 100),

		/**
		 * 滚动消息列表到底部
		 * 确保最新消息始终可见
		 */
		toBottom() {
			this.$nextTick(() => {
				setTimeout(() => {
					this.scrollTop = this.scrollTop + 1;
				}, 100);
			});
		},
		onFocus() {
			this.microphone = false;
		},
		toTest() {
			this.message = '制定一份端午节商城综合体的营销方案';
		},
		historyAdd() {
			// Mock模式下不调用真实API
			if (this.mockMode) {
				console.log('Mock模式：跳过历史记录创建和连接初始化');
				return;
			}

			console.log('正式模式：开始创建对话历史记录和建立连接');

			// 获取打开一个新的对话的historyId
			chatOpenNewHistory({
				customerNo: this.config.userInfo.userId,
				assistantNo: '1727988700871720962',
				aiAgentId: this.agentIdAgent
			})
				.then((res) => {
					console.log('✅ 对话历史记录创建成功', res.data);
					let data = res.data;
					this.historyId = data.serialNo;
					this.queryParams.dialogueHistoryNo = data.serialNo;

					// 使用正式的historyId建立连接
					this.connectSocketInit();
				})
				.catch((error) => {
					console.error('❌ 对话历史记录创建失败:', error);

					// 🔥 修复：即使API失败也要建立连接
					// 生成临时的historyId，确保WebSocket连接能建立
					const tempHistoryId = `temp-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
					console.log('⚠️ 使用临时historyId建立连接:', tempHistoryId);

					this.historyId = tempHistoryId;
					this.queryParams.dialogueHistoryNo = tempHistoryId;

					// 即使API失败也要尝试建立WebSocket连接
					this.connectSocketInit();

					// 显示用户友好的错误提示
					showToast('连接已建立，但历史记录功能可能受限');
				});
		},
		// 获取数据json
		getDataJson(data) {
			// 获取json数据
			const {
				taskOrnament,
				description
			} = data;
			let taskOrnamentObj = JSON.parse(taskOrnament || '{}');
			console.log('现在呢', taskOrnamentObj);
			taskOrnamentObj.nodes?.forEach((item) => (item.data = undefined));
			taskOrnamentObj.edges?.forEach((item) => (item.data = undefined));
			this.taskOrnamentStr = JSON.stringify(taskOrnamentObj);
			// 获取首条信息
			// fullWindowMessage.value.tips = description;
			this.recordList.push({
				createTime: getCurrentDateTime(),
				type: 2,
				content: description
			});
			console.log('新数据是', this.taskOrnamentStr, this.recordList);
		},
		getAiDetail() {
			// 获取打开一个新的对话的historyId
			chatTechnologyDetail({
				aiAgentId: this.agentIdAgent
			})
				.then((res) => {
					console.log('数据是', res.data);
					this.getDataJson(res.data);
				})
				.catch(() => {
					console.log('智能体详情获取失败');
				});
		}
		// onResponseMessage(res) {
		// 	let _this = this;
		// 	clearInterval(_this.timer);
		// 	_this.timerShow = false;

		// 	let lastIndex = _this.recordList.length - 1;
		// 	if (_this.recordList[lastIndex].content.indexOf('AI助手思考中') === 0 || _this
		// 		.recordList[lastIndex].content.indexOf('图片绘制中') === 0) {
		// 		_this.recordList[lastIndex].content = '';
		// 	}
		// 	// 测试结束
		// 	_this.recordList[lastIndex].content = _this.recordList[lastIndex].content + res.answerResult;
		// 	_this.answerStatus = false;
		// 	// 确认数据追加类型
		// 	let {
		// 		chartType,
		// 		chartData
		// 	} = res;
		// 	if (chartType && chartData && !['[]', '{}'].includes(chartData)) {
		// 		console.log("当前数据类型", chartType)
		// 		_this.recordList[lastIndex].contentType = 'chart_' + chartType;
		// 		_this.recordList[lastIndex].contentAppendData = chartData;
		// 	}
		// 	// 测试开始
		// 	// activity, coupon, goods
		// 	// if (lastIndex - 1 >= 0) {
		// 	// 	const preContent = _this.recordList[lastIndex - 1].content;
		// 	// 	if (preContent.includes('活动')) {
		// 	// 		_this.recordList[lastIndex].contentType = 'activity';
		// 	// 	} else if (preContent.includes('优惠券')) {
		// 	// 		_this.recordList[lastIndex].contentType = 'coupon';
		// 	// 	} else if (preContent.includes('商品')) {
		// 	// 		_this.recordList[lastIndex].contentType = 'goods';
		// 	// 	} else if (preContent.includes('图表1')) {
		// 	// 		_this.recordList[lastIndex].contentType = 'chart_1';
		// 	// 	} else if (preContent.includes('图表2')) {
		// 	// 		_this.recordList[lastIndex].contentType = 'chart_2';
		// 	// 	} else if (preContent.includes('图表3')) {
		// 	// 		_this.recordList[lastIndex].contentType = 'chart_3';
		// 	// 	}
		// 	// }
		// },
		// setMessageApi() {
		// 	const _this = this;
		// 	if (!_this.taskOrnamentStr) {
		// 		showToast('请等待当前数据加载');
		// 		return;
		// 	}
		// 	if (!_this.message || _this.message === '' || _this.message.length <= 0) {
		// 		return;
		// 	}
		// 	if (_this.answerStatus) {
		// 		showToast('请等待当前对话完成');
		// 		return;
		// 	}
		// 	let message = _this.message;
		// 	_this.message = null;
		// 	_this.microphone = false;
		// 	_this.recordList.push({
		// 		createTime: getCurrentDateTime(),
		// 		type: 1,
		// 		content: message
		// 	});
		// 	_this.toBottom();
		// 	_this.answerStatus = true;
		// 	//模拟回答中动画
		// 	_this.recordList.push({
		// 		createTime: getCurrentDateTime(),
		// 		type: 2,
		// 		content: '.'
		// 	});
		// 	let lastIndex = _this.recordList.length - 1;

		// 	let msg = 'AI助手思考中';
		// 	// 调用接口
		// 	chatGetAiAgentChat({
		// 			question: message,
		// 			taskOrnament: _this.taskOrnamentStr
		// 		})
		// 		.then((res) => {
		// 			console.log("数据是", res.data)
		// 			this.onResponseMessage(res.data);
		// 		})
		// 		.catch((err) => {
		// 			console.log('请求失败');
		// 		}).finally(() => {
		// 			_this.timerShow = false;

		// 			_this.answerStatus = false;
		// 		});
		// 	// 模拟等待
		// 	_this.timer = setInterval(() => {
		// 		_this.timerShow = true;

		// 		let content = _this.recordList[lastIndex].content;
		// 		content = content.replace(msg, '');
		// 		if (content.length >= 3) {
		// 			content = msg + '.';
		// 		} else {
		// 			content = msg + content + '.';
		// 		}
		// 		_this.recordList[lastIndex].content = content;
		// 	}, 300);
		// }
	}
};
</script>

<style lang="scss" scoped>
view {
	box-sizing: border-box;
}

.fade-enter-active,
.fade-leave-active {
	transition: opacity 0.2s ease;
}

.fade-enter-from,
.fade-leave-to {
	opacity: 0;
}

.fade-enter-to,
.fade-leave-from {
	opacity: 1;
}

@include b(aidialogue) {
	overflow: hidden;
	padding-top: 2rpx;
	background-size: 100% 100%;
	position: relative;
	background-position: center center;
	background-repeat: no-repeat;
	background-size: cover;
	display: flex;
	flex-direction: column;
	height: 100%;
	/* 确保占满父容器 */

	@include b(aidialogue-bg) {
		position: relative;
		height: 100%;
		display: flex;
		flex-direction: column;

		@include e(role) {
			position: absolute;
			bottom: 0;
			left: 0;
			right: 0;
			height: calc(100% - 100rpx);
			z-index: 0;
			margin: 0 auto;
		}

		@include m(float) {
			z-index: 1;
		}
	}

	@include b(aidialogue-header) {
		// background: linear-gradient(90deg, #E7FCF6 0%, #F7FFEE 50%, #DFF8FF 100%);
		background-size: cover !important;
		background-repeat: no-repeat !important;
		margin: 32rpx 32rpx 0;
		border-radius: 24rpx;
		flex-shrink: 0;
		/* 防止被压缩 */
		// padding: 32rpx;
	}

	@include b(aidialogue-content) {
		position: relative;
		z-index: 1;
		border-top-right-radius: 20rpx;
		border-top-left-radius: 20rpx;
		flex: 1;
		/* 占据剩余空间 */
		overflow-y: auto;
		min-height: 0;
		/* 重要：允许flex子项缩小 */

		@include eb(footer) {
			@include eb(copy) {
				display: flex;
				align-items: center;
				margin-right: 30rpx;

				@include e(text) {
					margin-left: 10rpx;
					color: #1aa0ff;
					font-size: 24rpx;
					white-space: nowrap;

					&.is-action {
						color: #8848cb;
					}
				}
			}
		}
	}

	@include b(aidialogue-input-area) {
		flex-shrink: 0;
		/* 防止被压缩 */
		padding-bottom: env(safe-area-inset-bottom);
		/* 适配安全区域 */
	}

	&.is-default-bg {
		background: #ffffff url('https://img.yummall.cn/wxapp/study/img/ai-assistant-bg2.png') top center no-repeat;
		background-size: contain;

		@include b(aidialogue-content) {
			background: -webkit-linear-gradient(top, #ffffff, #f3f4f8 120rpx);
		}
	}

	@include b(aidialogue-tabbar) {
		// #ifndef H5
		height: calc(120rpx + env(safe-area-inset-bottom));
		// #endif
		// #ifdef H5
		height: calc(160rpx);
		// #endif
		position: relative;

		@include e(box) {
			position: absolute;
			bottom: 0;
			left: 0;
			right: 0;
			z-index: 99;
			border-radius: 12px 12px 0px 0px;

			&.is-min {
				background: rgba(255, 255, 255, 0.7);
			}
		}

		@include e(content) {
			max-width: 1800rpx;
			margin: 0 auto;

			@include eb(input) {
				display: flex;
				align-items: center;
				padding: 16rpx 24rpx;

				@include e(audio) {
					margin-right: 28rpx;
				}

				@include e(textarea) {
					flex-grow: 1;
					min-height: 80rpx;
					border-radius: 88rpx;
					border: 4rpx solid transparent;
					// background-clip: padding-box, border-box;
					// background-origin: padding-box, border-box;
					// background-image: linear-gradient(to right, #fff, #fff), linear-gradient(to left, #5ee1fcff, #9caaf6ff, #9e8cf6ff, #5d8bfdff);
					background: rgba(255, 255, 255, 0.8);
					border: 2px solid #9e8cf6ff;
					border-radius: 44rpx;
					box-sizing: content-box;
					display: flex;
					justify-content: space-between;
					align-items: center;

					@include e(inner) {
						min-height: 48rpx;
						max-height: 500rpx;
						padding: 16rpx 24rpx;
						box-sizing: content-box;
						border-radius: 80rpx;
						width: calc(100% - 32rpx - 80rpx);
						line-height: 48rpx;
						font-size: 28rpx;

						// &::placeholder {
						// 	line-height: 48rpx;
						// }
					}

					@include e(confirm) {
						width: 56rpx;
						height: 56rpx;
						margin-right: 18rpx;
						background-color: #26a5ff;
						border-radius: 50%;
						display: flex;
						justify-content: center;
						align-items: center;
					}
				}
			}
		}
	}
}
</style>
